
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class HJ43 {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int y = sc.nextInt();
        int[][] map = new int[x][y];
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                map[i][j] = sc.nextInt();
            }
        }
        List<pos> list = new ArrayList<>();
        dfs(list,0,0,map);
        for (pos pos : list) {
            System.out.println("("+pos.x+","+pos.y+")");
        }
    }

    public static boolean dfs(List<pos> list,int x,int y,int[][] map){
        list.add(new pos(x,y));
        map[x][y]=1;

        if (x == map.length-1 && y == map[0].length-1){
            return true;
        }
        if (x+1 < map.length && map[x+1][y] == 0){
            if(dfs(list,x+1,y,map)){
                return true;
            }
        }
        if(x-1>-1 && map[x-1][y] == 0){
            if(dfs(list,x-1,y,map)){
                return true;
            }
        }
        if(y+1 <map[0].length && map[x][y+1] == 0){
            if (dfs(list,x,y+1,map)){
                return true;
            }
        }
        if(y-1 > -1 && map[x][y-1] == 0){
            if(dfs(list,x,y-1,map)){
                return true;
            }
        }
        //不满足上述条件，走到了这一步说明是死胡同了，需要回退
        list.remove(list.size()-1);
        map[x][y]=0;
        return false;
    }

    public static class pos{
        int x;
        int y;

        public pos(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

/*import java.io.*;
import java.util.Stack;

public class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();
        str = str.replace("[","("); // 将括号统一为小括号
        str = str.replace("]",")");
        str = str.replace("{","(");
        str = str.replace("}",")");
        System.out.println(solve(str));
    }

  /*
  	递归思想，从内到外处理括号，用栈存放操作数和中间结果。
    +运算符直接入栈，-运算符乘-1入栈，乘除运算符计算完入栈，
    最终栈内所有数相加即是结果
  */
/*public static int solve(String s) {
    Stack<Integer> nums = new Stack<>(); // 存放操作数和中间计算结果
    char[] expr = s.toCharArray();
    // 初始数字
    int num = 0;
    // 初始运算符（让第一个数字直接入栈）
    char sign = '+';
    for (int i =0; i < s.length(); i ++) {
        char ch = expr[i]; // 当前字符
        if (ch == ' ') continue; // 是空格，跳过
        if (Character.isDigit(ch)) { // 是数字，进行拼接
            num = num*10 + (ch - '0');
        }
        if (ch == '(') { // 是左括号，应当进入递归
            // 找到当前左括号对应的右括号
            int j = i + 1;
            int count = 1;
            while (count > 0) { // count为0时的j即是对应右括号的索引
                if (expr[j] == ')') count--;
                if (expr[j] == '(') count++;
                j++;
            }
            // 使用左右括号的对应索引进行递归，计算括号内表达式
            num = solve(s.substring(i+1, j-1));
            i = j - 1; // 计算完后更新索引（跳过计算完成的括号）
        }
        // 遇到符号，对操作数进行相应的处理后入栈（处理上一个符号）
        if (!Character.isDigit(ch) || i == s.length() - 1) {
            if (sign == '+') {
                nums.push(num); // 上一个符号是加号，直接把操作数入栈
            }
            else if (sign == '-') {
                nums.push(-1*num); // 上一个符号是减号，操作数取反再
            }
            else if (sign == '*') {
                nums.push(nums.pop()*num); // 上一个符号是乘号，把乘号前面的操作数取出来进行计算再入栈
            }
            else if (sign == '/') {
                nums.push(nums.pop()/num); // 上一个符号是除号，把乘号前面的操作数取出来进行计算再入栈
            }
            sign = ch; // 把符号更新为当前符号
            num = 0; // 把操作数重置为零
        }
    }

    int res = 0;
    while (!nums.isEmpty()) {
        res += nums.pop(); // 栈内数据相加即是结果
    }
    return res;
}

}
*/

